YES(O(1),O(n^3)) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , +(@x, @y) -> #add(@x, @y) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) } Weak Trs: { #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We add following dependency tuples: Strict DPs: { #abs^#(#0()) -> c_1() , #abs^#(#neg(@x)) -> c_2() , #abs^#(#pos(@x)) -> c_3() , #abs^#(#s(@x)) -> c_4() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , lineMult#1^#(nil(), @l) -> c_14() , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , makeBase#1^#(nil()) -> c_18() , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , mkBase#1^#(nil()) -> c_32() , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultList#1^#(nil(), @acc) -> c_28() , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#1^#(nil()) -> c_39() , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose#3^#(nil(), @l) -> c_49() , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } and mark the set of starting terms. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { #abs^#(#0()) -> c_1() , #abs^#(#neg(@x)) -> c_2() , #abs^#(#pos(@x)) -> c_3() , #abs^#(#s(@x)) -> c_4() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , lineMult#1^#(nil(), @l) -> c_14() , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , makeBase#1^#(nil()) -> c_18() , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , mkBase#1^#(nil()) -> c_32() , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultList#1^#(nil(), @acc) -> c_28() , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#1^#(nil()) -> c_39() , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose#3^#(nil(), @l) -> c_49() , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) Consider the dependency graph 1: #abs^#(#0()) -> c_1() 2: #abs^#(#neg(@x)) -> c_2() 3: #abs^#(#pos(@x)) -> c_3() 4: #abs^#(#s(@x)) -> c_4() 5: *^#(@x, @y) -> c_5(#mult^#(@x, @y)) -->_1 #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) :59 -->_1 #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) :58 -->_1 #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) :56 -->_1 #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) :55 -->_1 #mult^#(#pos(@x), #0()) -> c_57() :57 -->_1 #mult^#(#neg(@x), #0()) -> c_54() :54 -->_1 #mult^#(#0(), #pos(@y)) -> c_53() :53 -->_1 #mult^#(#0(), #neg(@y)) -> c_52() :52 -->_1 #mult^#(#0(), #0()) -> c_51() :51 6: +^#(@x, @y) -> c_6(#add^#(@x, @y)) -->_1 #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64 -->_1 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63 -->_1 #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :62 -->_1 #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) :61 -->_1 #add^#(#0(), @y) -> c_60() :60 7: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) -->_1 attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) :8 -->_1 attach#1^#(nil(), @m) -> c_9() :9 8: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) -->_1 attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) :10 -->_1 attach#2^#(nil(), @x, @xs) -> c_11() :11 9: attach#1^#(nil(), @m) -> c_9() 10: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) -->_1 attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) :7 11: attach#2^#(nil(), @x, @xs) -> c_11() 12: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) -->_1 lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) :13 -->_1 lineMult#1^#(nil(), @l) -> c_14() :14 13: lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) -->_1 mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) :15 -->_2 lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) :12 14: lineMult#1^#(nil(), @l) -> c_14() 15: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) -->_1 mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) :17 -->_1 mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) :16 16: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) -->_1 mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) :40 -->_1 mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) :39 17: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) -->_1 #abs^#(#0()) -> c_1() :1 18: makeBase^#(@m) -> c_16(makeBase#1^#(@m)) -->_1 makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) :19 -->_1 makeBase#1^#(nil()) -> c_18() :20 19: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) -->_1 mkBase^#(@m) -> c_19(mkBase#1^#(@m)) :21 20: makeBase#1^#(nil()) -> c_18() 21: mkBase^#(@m) -> c_19(mkBase#1^#(@m)) -->_1 mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) :22 -->_1 mkBase#1^#(nil()) -> c_32() :23 22: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) -->_1 mkBase^#(@m) -> c_19(mkBase#1^#(@m)) :21 23: mkBase#1^#(nil()) -> c_32() 24: matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) -->_2 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26 -->_1 matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) :25 -->_3 makeBase^#(@m) -> c_16(makeBase#1^#(@m)) :18 25: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) -->_1 matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :29 -->_1 matrixMult'#1^#(nil(), @m2) -> c_24() :30 26: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) -->_1 transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :27 -->_1 transAcc#1^#(nil(), @base) -> c_44() :28 27: transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) -->_2 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26 -->_1 attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) :7 28: transAcc#1^#(nil(), @base) -> c_44() 29: matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) -->_2 matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) :25 -->_1 lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) :12 30: matrixMult'#1^#(nil(), @m2) -> c_24() 31: matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) -->_2 matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :24 -->_1 matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :24 32: matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) :33 -->_1 matrixMultList#1^#(nil(), @acc) -> c_28() :34 33: matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) -->_1 matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) :32 -->_2 matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :24 34: matrixMultList#1^#(nil(), @acc) -> c_28() 35: matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) -->_2 transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) :36 -->_1 matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) :25 36: transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) -->_1 transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) :37 -->_1 transpose#1^#(nil(), @m) -> c_46() :38 37: transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) -->_1 transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) :47 -->_2 split^#(@m) -> c_37(split#1^#(@m)) :41 38: transpose#1^#(nil(), @m) -> c_46() 39: mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) -->_3 mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) :15 -->_1 +^#(@x, @y) -> c_6(#add^#(@x, @y)) :6 -->_2 *^#(@x, @y) -> c_5(#mult^#(@x, @y)) :5 40: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) -->_1 #abs^#(#0()) -> c_1() :1 41: split^#(@m) -> c_37(split#1^#(@m)) -->_1 split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) :42 -->_1 split#1^#(nil()) -> c_39() :43 42: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) -->_1 split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) :44 -->_1 split#2^#(nil(), @ls) -> c_41() :45 43: split#1^#(nil()) -> c_39() 44: split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) -->_1 split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() :46 -->_2 split^#(@m) -> c_37(split#1^#(@m)) :41 45: split#2^#(nil(), @ls) -> c_41() 46: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() 47: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) -->_1 transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) :48 -->_1 transpose#3^#(nil(), @l) -> c_49() :49 48: transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) -->_1 transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) :36 49: transpose#3^#(nil(), @l) -> c_49() 50: transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) -->_1 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26 -->_2 makeBase^#(@m) -> c_16(makeBase#1^#(@m)) :18 51: #mult^#(#0(), #0()) -> c_51() 52: #mult^#(#0(), #neg(@y)) -> c_52() 53: #mult^#(#0(), #pos(@y)) -> c_53() 54: #mult^#(#neg(@x), #0()) -> c_54() 55: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 56: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 57: #mult^#(#pos(@x), #0()) -> c_57() 58: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 59: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 60: #add^#(#0(), @y) -> c_60() 61: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70 -->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69 -->_1 #pred^#(#neg(#s(@x))) -> c_66() :68 -->_1 #pred^#(#0()) -> c_65() :67 62: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) -->_2 #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64 -->_2 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63 -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70 -->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69 -->_1 #pred^#(#neg(#s(@x))) -> c_66() :68 -->_1 #pred^#(#0()) -> c_65() :67 63: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) -->_1 #succ^#(#pos(#s(@x))) -> c_72() :74 -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73 -->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72 -->_1 #succ^#(#0()) -> c_69() :71 64: #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) -->_1 #succ^#(#pos(#s(@x))) -> c_72() :74 -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73 -->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72 -->_1 #succ^#(#0()) -> c_69() :71 -->_2 #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64 -->_2 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63 65: #natmult^#(#0(), @y) -> c_73() 66: #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) -->_1 #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) :76 -->_1 #natadd^#(#0(), @y) -> c_75() :75 -->_2 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_2 #natmult^#(#0(), @y) -> c_73() :65 67: #pred^#(#0()) -> c_65() 68: #pred^#(#neg(#s(@x))) -> c_66() 69: #pred^#(#pos(#s(#0()))) -> c_67() 70: #pred^#(#pos(#s(#s(@x)))) -> c_68() 71: #succ^#(#0()) -> c_69() 72: #succ^#(#neg(#s(#0()))) -> c_70() 73: #succ^#(#neg(#s(#s(@x)))) -> c_71() 74: #succ^#(#pos(#s(@x))) -> c_72() 75: #natadd^#(#0(), @y) -> c_75() 76: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) -->_1 #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) :76 -->_1 #natadd^#(#0(), @y) -> c_75() :75 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { #abs^#(#neg(@x)) -> c_2() , #abs^#(#pos(@x)) -> c_3() , #abs^#(#s(@x)) -> c_4() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , lineMult#1^#(nil(), @l) -> c_14() , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , makeBase#1^#(nil()) -> c_18() , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , mkBase#1^#(nil()) -> c_32() , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultList#1^#(nil(), @acc) -> c_28() , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#1^#(nil()) -> c_39() , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose#3^#(nil(), @l) -> c_49() , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We estimate the number of application of {1,2,3,6,8,11,17,20,25,27,31,35,40,42,43,46} by applications of Pre({1,2,3,6,8,11,17,20,25,27,31,35,40,42,43,46}) = {4,5,9,14,15,18,22,23,29,33,36,37,38,39,41,44}. Here rules are labeled as follows: DPs: { 1: #abs^#(#0()) -> c_1() , 2: *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , 3: +^#(@x, @y) -> c_6(#add^#(@x, @y)) , 4: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , 5: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , 6: attach#1^#(nil(), @m) -> c_9() , 7: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , 8: attach#2^#(nil(), @x, @xs) -> c_11() , 9: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , 10: lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , 11: lineMult#1^#(nil(), @l) -> c_14() , 12: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , 13: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , 14: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , 15: makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , 16: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , 17: makeBase#1^#(nil()) -> c_18() , 18: mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , 19: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , 20: mkBase#1^#(nil()) -> c_32() , 21: matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 22: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , 23: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , 24: transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , 25: transAcc#1^#(nil(), @base) -> c_44() , 26: matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 27: matrixMult'#1^#(nil(), @m2) -> c_24() , 28: matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 29: matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , 30: matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 31: matrixMultList#1^#(nil(), @acc) -> c_28() , 32: matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 33: transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , 34: transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , 35: transpose#1^#(nil(), @m) -> c_46() , 36: mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , 37: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , 38: split^#(@m) -> c_37(split#1^#(@m)) , 39: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , 40: split#1^#(nil()) -> c_39() , 41: split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , 42: split#2^#(nil(), @ls) -> c_41() , 43: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , 44: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , 45: transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , 46: transpose#3^#(nil(), @l) -> c_49() , 47: transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) , 48: #mult^#(#0(), #0()) -> c_51() , 49: #mult^#(#0(), #neg(@y)) -> c_52() , 50: #mult^#(#0(), #pos(@y)) -> c_53() , 51: #mult^#(#neg(@x), #0()) -> c_54() , 52: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , 53: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , 54: #mult^#(#pos(@x), #0()) -> c_57() , 55: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , 56: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , 57: #add^#(#0(), @y) -> c_60() , 58: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , 59: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 60: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , 61: #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 62: #natmult^#(#0(), @y) -> c_73() , 63: #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , 64: #pred^#(#0()) -> c_65() , 65: #pred^#(#neg(#s(@x))) -> c_66() , 66: #pred^#(#pos(#s(#0()))) -> c_67() , 67: #pred^#(#pos(#s(#s(@x)))) -> c_68() , 68: #succ^#(#0()) -> c_69() , 69: #succ^#(#neg(#s(#0()))) -> c_70() , 70: #succ^#(#neg(#s(#s(@x)))) -> c_71() , 71: #succ^#(#pos(#s(@x))) -> c_72() , 72: #natadd^#(#0(), @y) -> c_75() , 73: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult#1^#(nil(), @l) -> c_14() , makeBase#1^#(nil()) -> c_18() , mkBase#1^#(nil()) -> c_32() , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMultList#1^#(nil(), @acc) -> c_28() , transpose#1^#(nil(), @m) -> c_46() , split#1^#(nil()) -> c_39() , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#3^#(nil(), @l) -> c_49() , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We estimate the number of application of {8,25} by applications of Pre({8,25}) = {6,7}. Here rules are labeled as follows: DPs: { 1: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , 2: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , 4: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , 5: lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , 6: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , 7: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , 8: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , 9: makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , 10: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , 11: mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , 12: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , 13: matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 14: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , 15: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , 16: transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , 17: matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 18: matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 19: matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , 20: matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 21: matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 22: transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , 23: transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , 24: mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , 25: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , 26: split^#(@m) -> c_37(split#1^#(@m)) , 27: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , 28: split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , 29: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , 30: transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , 31: transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) , 32: #abs^#(#0()) -> c_1() , 33: *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , 34: #mult^#(#0(), #0()) -> c_51() , 35: #mult^#(#0(), #neg(@y)) -> c_52() , 36: #mult^#(#0(), #pos(@y)) -> c_53() , 37: #mult^#(#neg(@x), #0()) -> c_54() , 38: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , 39: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , 40: #mult^#(#pos(@x), #0()) -> c_57() , 41: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , 42: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , 43: +^#(@x, @y) -> c_6(#add^#(@x, @y)) , 44: #add^#(#0(), @y) -> c_60() , 45: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , 46: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 47: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , 48: #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 49: attach#1^#(nil(), @m) -> c_9() , 50: attach#2^#(nil(), @x, @xs) -> c_11() , 51: lineMult#1^#(nil(), @l) -> c_14() , 52: makeBase#1^#(nil()) -> c_18() , 53: mkBase#1^#(nil()) -> c_32() , 54: transAcc#1^#(nil(), @base) -> c_44() , 55: matrixMult'#1^#(nil(), @m2) -> c_24() , 56: matrixMultList#1^#(nil(), @acc) -> c_28() , 57: transpose#1^#(nil(), @m) -> c_46() , 58: split#1^#(nil()) -> c_39() , 59: split#2^#(nil(), @ls) -> c_41() , 60: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , 61: transpose#3^#(nil(), @l) -> c_49() , 62: #natmult^#(#0(), @y) -> c_73() , 63: #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , 64: #pred^#(#0()) -> c_65() , 65: #pred^#(#neg(#s(@x))) -> c_66() , 66: #pred^#(#pos(#s(#0()))) -> c_67() , 67: #pred^#(#pos(#s(#s(@x)))) -> c_68() , 68: #succ^#(#0()) -> c_69() , 69: #succ^#(#neg(#s(#0()))) -> c_70() , 70: #succ^#(#neg(#s(#s(@x)))) -> c_71() , 71: #succ^#(#pos(#s(@x))) -> c_72() , 72: #natadd^#(#0(), @y) -> c_75() , 73: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult#1^#(nil(), @l) -> c_14() , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase#1^#(nil()) -> c_18() , mkBase#1^#(nil()) -> c_32() , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMultList#1^#(nil(), @acc) -> c_28() , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split#1^#(nil()) -> c_39() , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#3^#(nil(), @l) -> c_49() , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult#1^#(nil(), @l) -> c_14() , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase#1^#(nil()) -> c_18() , mkBase#1^#(nil()) -> c_32() , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMultList#1^#(nil(), @acc) -> c_28() , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split#1^#(nil()) -> c_39() , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#3^#(nil(), @l) -> c_49() , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We replace rewrite rules by usable rules: Weak Usable Rules: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 1: attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , 18: matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , 20: matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 29: transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Trs: { *(@x, @y) -> #mult(@x, @y) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , mkBase#1(nil()) -> nil() , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1, 2, 3}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1, 2}, Uargs(c_16) = {1, 2}, Uargs(c_17) = {1, 2}, Uargs(c_18) = {1}, Uargs(c_19) = {1, 2}, Uargs(c_20) = {1, 2}, Uargs(c_21) = {1}, Uargs(c_22) = {1, 2}, Uargs(c_23) = {1}, Uargs(c_24) = {1}, Uargs(c_25) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1}, Uargs(c_29) = {1, 2} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [1] x1 + [1] [#pos](x1) = [0] [#s](x1) = [0] [*](x1, x2) = [1] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [0] [nil] = [0] [lineMult](x1, x2) = [1] x2 + [1] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [1] [makeBase](x1) = [0] [makeBase#1](x1) = [1] x1 + [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [1] x1 + [0] [transAcc](x1, x2) = [0] [matrixMult'](x1, x2) = [1] [matrixMult'#1](x1, x2) = [0] [transpose](x1) = [0] [mkBase#1](x1) = [1] [mult#1](x1, x2) = [0] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x1 + [1] x2 + [0] [transpose#1](x1, x2) = [1] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [1] x1 + [1] [attach#1^#](x1, x2) = [1] x1 + [0] [attach#2^#](x1, x2, x3) = [1] x3 + [1] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [1] x2 + [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [1] x1 + [0] [transAcc#1^#](x1, x2) = [1] x1 + [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x2 + [1] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [1] x1 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2) = [1] x1 + [1] x2 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1, x2) = [1] x1 + [1] x2 + [0] [c_16](x1, x2) = [1] x1 + [1] x2 + [0] [c_17](x1, x2) = [1] x1 + [1] x2 + [1] [c_18](x1) = [1] x1 + [0] [c_19](x1, x2) = [1] x1 + [1] x2 + [0] [c_20](x1, x2) = [1] x1 + [1] x2 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1, x2) = [1] x1 + [1] x2 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1) = [1] x1 + [0] [c_25](x1) = [1] x1 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1) = [1] x1 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] This order satisfies following ordering constraints [attach^#(@line, @m)] = [1] @line + [1] > [1] @line + [0] = [c_1(attach#1^#(@line, @m))] [attach#1^#(::(@x, @xs), @m)] = [1] @x + [1] @xs + [1] >= [1] @xs + [1] = [c_2(attach#2^#(@m, @x, @xs))] [attach#2^#(::(@l, @ls), @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [c_3(attach^#(@xs, @ls))] [lineMult^#(@l, @m2)] = [0] >= [0] = [c_4(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0] >= [0] = [c_5(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0] >= [0] = [c_6(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_7(mult#2^#(@l2, @x, @xs))] [makeBase^#(@m)] = [0] >= [0] = [c_8(makeBase#1^#(@m))] [makeBase#1^#(::(@l, @m'))] = [0] >= [0] = [c_9(mkBase^#(@l))] [mkBase^#(@m)] = [0] >= [0] = [c_10(mkBase#1^#(@m))] [mkBase#1^#(::(@l, @m'))] = [0] >= [0] = [c_11(mkBase^#(@m'))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2))] [matrixMult'^#(@m1, @m2)] = [0] >= [0] = [c_13(matrixMult'#1^#(@m1, @m2))] [transAcc^#(@m, @base)] = [1] @m + [0] >= [1] @m + [0] = [c_14(transAcc#1^#(@m, @base))] [transAcc#1^#(::(@l, @m'), @base)] = [1] @l + [1] @m' + [1] >= [1] @l + [1] @m' + [1] = [c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] >= [1] @m2 + [1] @m3 + [1] = [c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [1] > [1] @mm + [0] = [c_18(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @m + [1] @ms + [1] = [c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m))] [matrixMultOld^#(@m1, @m2)] = [1] @m1 + [1] @m2 + [1] > [0] = [c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))] [transpose^#(@m)] = [0] >= [0] = [c_21(transpose#1^#(@m, @m))] [transpose#1^#(::(@xs, @xss), @m)] = [0] >= [0] = [c_22(transpose#2^#(split(@m)), split^#(@m))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_23(mult^#(@xs, @ys))] [split^#(@m)] = [0] >= [0] = [c_24(split#1^#(@m))] [split#1^#(::(@l, @ls))] = [0] >= [0] = [c_25(split#2^#(@l, @ls))] [split#2^#(::(@x, @xs), @ls)] = [0] >= [0] = [c_26(split^#(@ls))] [transpose#2^#(tuple#2(@l, @m'))] = [0] >= [0] = [c_27(transpose#3^#(@m', @l))] [transpose#3^#(::(@y, @ys), @l)] = [0] >= [0] = [c_28(transpose^#(::(@y, @ys)))] [transpose'^#(@m)] = [1] @m + [1] > [1] @m + [0] = [c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))] Consider the set of all dependency pairs DPs: { 1: attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , 2: attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , 4: lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , 5: lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , 6: mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , 7: mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , 8: makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , 9: makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , 10: mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , 11: mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , 12: matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 13: matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , 14: transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , 15: transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , 16: matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 17: matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 18: matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , 19: matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 20: matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 21: transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , 22: transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , 23: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , 24: split^#(@m) -> c_24(split#1^#(@m)) , 25: split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , 26: split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , 27: transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , 28: transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , 29: transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {1,18,20,29}. These cover all (indirect) predecessors of dependency pairs {1,2,3,8,9,12,17,18,19,20,29}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) } Weak DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) } Weak DPs: { makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , mkBase^#(@m) -> c_5(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m')) , matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_11(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_12(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys)) , split^#(@m) -> c_14(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_18(transpose^#(::(@y, @ys))) } Weak DPs: { makeBase^#(@m) -> c_19(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_22(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_23(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_24(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 6: mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m')) , 20: makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l)) , 22: matrixMult3^#(@m1, @m2, @m3) -> c_22(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) } Trs: { attach#1(nil(), @m) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1, 2}, Uargs(c_11) = {1}, Uargs(c_12) = {1, 2}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1, 2, 3}, Uargs(c_22) = {1, 2}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1, 2} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [0] [#pos](x1) = [1] x1 + [0] [#s](x1) = [0] [*](x1, x2) = [0] [#mult](x1, x2) = [1] x2 + [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [1] x1 + [0] [nil] = [0] [lineMult](x1, x2) = [1] x2 + [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [1] x1 + [0] [makeBase#1](x1) = [1] x1 + [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [1] x2 + [0] [transAcc](x1, x2) = [1] x2 + [1] [matrixMult'](x1, x2) = [0] [matrixMult'#1](x1, x2) = [0] [transpose](x1) = [0] [mkBase#1](x1) = [1] [mult#1](x1, x2) = [1] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [1] x1 + [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [1] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x1 + [1] x2 + [0] [transpose#1](x1, x2) = [1] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [1] x1 + [0] [makeBase#1^#](x1) = [1] x1 + [0] [mkBase^#](x1) = [1] x1 + [0] [mkBase#1^#](x1) = [1] x1 + [0] [matrixMult^#](x1, x2) = [1] x2 + [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x2 + [1] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1] [transpose^#](x1) = [1] [transpose#1^#](x1, x2) = [1] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [1] [transpose#3^#](x1, x2) = [1] [transpose'^#](x1) = [1] x1 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1, x2) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1, x2, x3) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1, x2) = [0] [c_16](x1, x2) = [0] [c_17](x1, x2) = [0] [c_18](x1) = [0] [c_19](x1, x2) = [0] [c_20](x1, x2) = [0] [c_21](x1) = [0] [c_22](x1, x2) = [0] [c_23](x1) = [0] [c_24](x1) = [0] [c_25](x1) = [0] [c_26](x1) = [0] [c_27](x1) = [0] [c_28](x1) = [0] [c_29](x1, x2) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1, x2) = [1] x1 + [1] x2 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1, x2) = [1] x1 + [1] x2 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1, x2) = [1] x1 + [1] x2 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1) = [1] x1 + [0] [c_21](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_22](x1, x2) = [1] x1 + [1] x2 + [0] [c_23](x1) = [1] x1 + [1] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1, x2) = [1] x1 + [1] x2 + [1] This order satisfies following ordering constraints [lineMult^#(@l, @m2)] = [0] >= [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0] >= [0] = [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0] >= [0] = [c_3(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_4(mult#2^#(@l2, @x, @xs))] [makeBase^#(@m)] = [1] @m + [0] >= [1] @m + [0] = [c_19(makeBase#1^#(@m))] [makeBase#1^#(::(@l, @m'))] = [1] @l + [1] @m' + [1] > [1] @l + [0] = [c_20(mkBase^#(@l))] [mkBase^#(@m)] = [1] @m + [0] >= [1] @m + [0] = [c_5(mkBase#1^#(@m))] [mkBase#1^#(::(@l, @m'))] = [1] @l + [1] @m' + [1] > [1] @m' + [0] = [c_6(mkBase^#(@m'))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2))] [matrixMult'^#(@m1, @m2)] = [0] >= [0] = [c_7(matrixMult'#1^#(@m1, @m2))] [transAcc^#(@m, @base)] = [0] >= [0] = [c_8(transAcc#1^#(@m, @base))] [transAcc#1^#(::(@l, @m'), @base)] = [0] >= [0] = [c_9(transAcc^#(@m', @base))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] > [1] @m2 + [1] @m3 + [0] = [c_22(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [1] >= [1] @mm + [1] = [c_23(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @m + [1] @ms + [1] = [c_24(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m))] [matrixMultOld^#(@m1, @m2)] = [1] @m1 + [1] @m2 + [1] >= [1] = [c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))] [transpose^#(@m)] = [1] >= [1] = [c_11(transpose#1^#(@m, @m))] [transpose#1^#(::(@xs, @xss), @m)] = [1] >= [1] = [c_12(transpose#2^#(split(@m)), split^#(@m))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_13(mult^#(@xs, @ys))] [split^#(@m)] = [0] >= [0] = [c_14(split#1^#(@m))] [split#1^#(::(@l, @ls))] = [0] >= [0] = [c_15(split#2^#(@l, @ls))] [split#2^#(::(@x, @xs), @ls)] = [0] >= [0] = [c_16(split^#(@ls))] [transpose#2^#(tuple#2(@l, @m'))] = [1] >= [1] = [c_17(transpose#3^#(@m', @l))] [transpose#3^#(::(@y, @ys), @l)] = [1] >= [1] = [c_18(transpose^#(::(@y, @ys)))] [transpose'^#(@m)] = [1] @m + [1] >= [1] @m + [1] = [c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , 5: mkBase^#(@m) -> c_5(mkBase#1^#(@m)) , 6: mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m')) , 7: matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2)) , 8: transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base)) , 9: transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base)) , 10: matrixMult'#1^#(::(@l, @ls), @m2) -> c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 11: transpose^#(@m) -> c_11(transpose#1^#(@m, @m)) , 12: transpose#1^#(::(@xs, @xss), @m) -> c_12(transpose#2^#(split(@m)), split^#(@m)) , 13: mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys)) , 14: split^#(@m) -> c_14(split#1^#(@m)) , 15: split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls)) , 16: split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls)) , 17: transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l)) , 18: transpose#3^#(::(@y, @ys), @l) -> c_18(transpose^#(::(@y, @ys))) , 19: makeBase^#(@m) -> c_19(makeBase#1^#(@m)) , 20: makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l)) , 21: matrixMult^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 22: matrixMult3^#(@m1, @m2, @m3) -> c_22(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 23: matrixMultList^#(@acc, @mm) -> c_23(matrixMultList#1^#(@mm, @acc)) , 24: matrixMultList#1^#(::(@m, @ms), @acc) -> c_24(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 25: matrixMultOld^#(@m1, @m2) -> c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 26: transpose'^#(@m) -> c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {6,20,22}. These cover all (indirect) predecessors of dependency pairs {5,6,20,22,25,26}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_11(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_12(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys)) , split^#(@m) -> c_14(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_18(transpose^#(::(@y, @ys))) } Weak DPs: { makeBase^#(@m) -> c_19(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l)) , mkBase^#(@m) -> c_5(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_22(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_23(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_24(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { makeBase^#(@m) -> c_19(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l)) , mkBase^#(@m) -> c_5(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m')) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_11(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_12(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys)) , split^#(@m) -> c_14(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_18(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_22(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_23(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_24(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , transpose'^#(@m) -> c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_9(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_10(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys)) , split^#(@m) -> c_12(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_16(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2))) , matrixMult3^#(@m1, @m2, @m3) -> c_18(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_19(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_20(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 7: transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base)) , 18: matrixMult3^#(@m1, @m2, @m3) -> c_18(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 19: matrixMultList^#(@acc, @mm) -> c_19(matrixMultList#1^#(@mm, @acc)) , 22: transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) } Trs: { #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , attach#1(nil(), @m) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1, 2}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1, 2}, Uargs(c_18) = {1, 2}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2}, Uargs(c_21) = {1, 2}, Uargs(c_22) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [1] [#pos](x1) = [0] [#s](x1) = [1] [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [1] x1 + [0] [nil] = [1] [lineMult](x1, x2) = [1] x2 + [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [1] [makeBase#1](x1) = [1] x1 + [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [0] [transAcc](x1, x2) = [1] x2 + [1] [matrixMult'](x1, x2) = [1] [matrixMult'#1](x1, x2) = [1] x1 + [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [1] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [1] x1 + [1] [tuple#2](x1, x2) = [1] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x2 + [1] [transpose#1](x1, x2) = [1] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [1] x2 + [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [1] x1 + [0] [transAcc#1^#](x1, x2) = [1] x1 + [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x2 + [1] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1] [transpose^#](x1) = [1] [transpose#1^#](x1, x2) = [1] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [1] [transpose#3^#](x1, x2) = [1] [transpose'^#](x1) = [1] x1 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1, x2) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1, x2, x3) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1, x2) = [0] [c_16](x1, x2) = [0] [c_17](x1, x2) = [0] [c_18](x1) = [0] [c_19](x1, x2) = [0] [c_20](x1, x2) = [0] [c_21](x1) = [0] [c_22](x1, x2) = [0] [c_23](x1) = [0] [c_24](x1) = [0] [c_25](x1) = [0] [c_26](x1) = [0] [c_27](x1) = [0] [c_28](x1) = [0] [c_29](x1, x2) = [0] [c] = [0] [c_1](x1) = [0] [c_2](x1, x2) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1, x2) = [0] [c_11](x1) = [0] [c_12](x1, x2) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1) = [0] [c_16](x1) = [0] [c_17](x1) = [0] [c_18](x1) = [0] [c_19](x1) = [0] [c_20](x1) = [0] [c_21](x1, x2, x3) = [0] [c_22](x1, x2) = [0] [c_23](x1) = [0] [c_24](x1, x2) = [0] [c_25](x1, x2) = [0] [c_26](x1, x2) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1, x2) = [1] x1 + [1] x2 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1, x2) = [1] x1 + [1] x2 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1, x2) = [1] x1 + [1] x2 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1, x2) = [1] x1 + [1] x2 + [0] [c_18](x1, x2) = [1] x1 + [1] x2 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2) = [1] x1 + [1] x2 + [0] [c_21](x1, x2) = [1] x1 + [1] x2 + [0] [c_22](x1) = [1] x1 + [0] This order satisfies following ordering constraints [lineMult^#(@l, @m2)] = [0] >= [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0] >= [0] = [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0] >= [0] = [c_3(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_4(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)))] [matrixMult'^#(@m1, @m2)] = [0] >= [0] = [c_5(matrixMult'#1^#(@m1, @m2))] [transAcc^#(@m, @base)] = [1] @m + [0] >= [1] @m + [0] = [c_6(transAcc#1^#(@m, @base))] [transAcc#1^#(::(@l, @m'), @base)] = [1] @l + [1] @m' + [1] > [1] @m' + [0] = [c_7(transAcc^#(@m', @base))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] > [1] @m2 + [1] @m3 + [0] = [c_18(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [1] > [1] @mm + [0] = [c_19(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @m + [1] @ms + [1] = [c_20(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m))] [matrixMultOld^#(@m1, @m2)] = [1] @m1 + [1] @m2 + [1] >= [1] = [c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))] [transpose^#(@m)] = [1] >= [1] = [c_9(transpose#1^#(@m, @m))] [transpose#1^#(::(@xs, @xss), @m)] = [1] >= [1] = [c_10(transpose#2^#(split(@m)), split^#(@m))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_11(mult^#(@xs, @ys))] [split^#(@m)] = [0] >= [0] = [c_12(split#1^#(@m))] [split#1^#(::(@l, @ls))] = [0] >= [0] = [c_13(split#2^#(@l, @ls))] [split#2^#(::(@x, @xs), @ls)] = [0] >= [0] = [c_14(split^#(@ls))] [transpose#2^#(tuple#2(@l, @m'))] = [1] >= [1] = [c_15(transpose#3^#(@m', @l))] [transpose#3^#(::(@y, @ys), @l)] = [1] >= [1] = [c_16(transpose^#(::(@y, @ys)))] [transpose'^#(@m)] = [1] @m + [1] > [1] @m + [0] = [c_22(transAcc^#(@m, makeBase(@m)))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , 6: transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base)) , 7: transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base)) , 8: matrixMult'#1^#(::(@l, @ls), @m2) -> c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 9: transpose^#(@m) -> c_9(transpose#1^#(@m, @m)) , 10: transpose#1^#(::(@xs, @xss), @m) -> c_10(transpose#2^#(split(@m)), split^#(@m)) , 11: mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys)) , 12: split^#(@m) -> c_12(split#1^#(@m)) , 13: split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls)) , 14: split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls)) , 15: transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l)) , 16: transpose#3^#(::(@y, @ys), @l) -> c_16(transpose^#(::(@y, @ys))) , 17: matrixMult^#(@m1, @m2) -> c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2))) , 18: matrixMult3^#(@m1, @m2, @m3) -> c_18(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 19: matrixMultList^#(@acc, @mm) -> c_19(matrixMultList#1^#(@mm, @acc)) , 20: matrixMultList#1^#(::(@m, @ms), @acc) -> c_20(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 21: matrixMultOld^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 22: transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {7,18,19,22}. These cover all (indirect) predecessors of dependency pairs {6,7,17,18,19,20,21,22}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_9(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_10(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys)) , split^#(@m) -> c_12(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_16(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2))) , transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base)) , matrixMult3^#(@m1, @m2, @m3) -> c_18(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_19(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_20(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base)) , transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_9(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_10(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys)) , split^#(@m) -> c_12(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_16(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2))) , matrixMult3^#(@m1, @m2, @m3) -> c_18(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_19(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_20(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult^#(@m1, @m2) -> c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2))) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_7(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_8(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) , split^#(@m) -> c_10(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_14(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_17(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 11: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) } Trs: { attach#2(nil(), @x, @xs) -> nil() , makeBase#1(nil()) -> nil() , mkBase#1(nil()) -> nil() , split#1(nil()) -> tuple#2(nil(), nil()) , transAcc#1(nil(), @base) -> @base } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1, 2}, Uargs(c_17) = {1}, Uargs(c_18) = {1, 2}, Uargs(c_19) = {1, 2} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [0 0] x1 + [0] [1 1] [0] [#pos](x1) = [0 0] x1 + [0] [1 1] [0] [#s](x1) = [0 0] x1 + [0] [1 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [1 0] x2 + [0] [0 1] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [1] [nil] = [1] [0] [lineMult](x1, x2) = [1] [0] [lineMult#1](x1, x2) = [1 0] x2 + [1] [1 0] [1] [mult](x1, x2) = [0] [0] [makeBase](x1) = [1 0] x1 + [1] [1 1] [0] [makeBase#1](x1) = [1 0] x1 + [1] [1 1] [0] [mkBase](x1) = [1 1] x1 + [1] [0 1] [1] [matrixMult](x1, x2) = [1 0] x1 + [1] [1 1] [1] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [1 1] [0] [matrixMult'](x1, x2) = [1 1] x1 + [0] [1 0] [1] [matrixMult'#1](x1, x2) = [1 1] x1 + [0] [1 1] [1] [transpose](x1) = [1 0] x1 + [1] [1 0] [0] [mkBase#1](x1) = [1 1] x1 + [1] [0 1] [1] [mult#1](x1, x2) = [0] [0] [mult#2](x1, x2, x3) = [0 0] x2 + [0] [1 1] [0] [split](x1) = [1 0] x1 + [0] [1 0] [1] [split#1](x1) = [1 0] x1 + [0] [1 0] [1] [split#2](x1, x2) = [0 1] x1 + [1 0] x2 + [0] [1 1] [1 0] [1] [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0] [0 0] [1 1] [1] [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [1] [0 1] [1 1] [1 1] [1] [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [1 1] [0] [transpose#1](x1, x2) = [1] [0] [transpose#2](x1) = [1 0] x1 + [0] [1 0] [0] [transpose#3](x1, x2) = [0 0] x1 + [1 0] x2 + [0] [1 0] [0 1] [1] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0 0] x1 + [0] [1 0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0] [0] [lineMult#1^#](x1, x2) = [0] [0] [mult^#](x1, x2) = [0] [0] [mult#1^#](x1, x2) = [0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [0] [0] [matrixMult'^#](x1, x2) = [0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0] [0] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 0] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [0] [0] [matrixMultList#1^#](x1, x2) = [0] [0] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [1 1] x1 + [1] [0 0] [0] [transpose#1^#](x1, x2) = [1 1] x2 + [1] [0 0] [0] [mult#2^#](x1, x2, x3) = [0] [0] [split^#](x1) = [0 1] x1 + [0] [1 0] [0] [split#1^#](x1) = [0 1] x1 + [0] [0 0] [0] [split#2^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0 1] x1 + [0] [1 1] [0] [transpose#3^#](x1, x2) = [1 1] x1 + [1] [0 0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1, x2) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1, x2, x3) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1) = [0] [0] [c_15](x1, x2) = [0] [0] [c_16](x1, x2) = [0] [0] [c_17](x1, x2) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1, x2) = [0] [0] [c_20](x1, x2) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1, x2) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1) = [0] [0] [c_25](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] [c_28](x1) = [0] [0] [c_29](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [0] [0] [c_2](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1, x2) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1, x2) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1) = [0] [0] [c_21](x1, x2, x3) = [0] [0] [c_22](x1, x2) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1, x2) = [0] [0] [c_25](x1, x2) = [0] [0] [c_26](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [0] [0] [c_2](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1, x2) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1, x2) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1, x2) = [0] [0] [c_18](x1, x2) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1, x2) = [0] [0] [c_21](x1, x2) = [0] [0] [c_22](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_3](x1) = [1 1] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] [c_11](x1) = [1 0] x1 + [0] [0 0] [0] [c_12](x1) = [1 0] x1 + [0] [0 0] [0] [c_13](x1) = [1 0] x1 + [0] [0 0] [0] [c_14](x1) = [1 0] x1 + [0] [0 0] [0] [c_15](x1) = [1 0] x1 + [0] [0 0] [0] [c_16](x1, x2) = [1 0] x1 + [1 0] x2 + [1] [0 0] [0 0] [1] [c_17](x1) = [1 0] x1 + [0] [0 0] [0] [c_18](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_19](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [1] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [1] >= [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [1] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] >= [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [1] [0 1] [1] >= [1] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [2] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [2] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [2] [0 0] [0 0] [1] > [1] [0] = [nil()] [makeBase(@m)] = [1 0] @m + [1] [1 1] [0] >= [1 0] @m + [1] [1 1] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [1 1] @l + [1 0] @m' + [1] [1 1] [1 1] [1] >= [1 1] @l + [1] [0 1] [1] = [mkBase(@l)] [makeBase#1(nil())] = [2] [1] > [1] [0] = [nil()] [mkBase(@m)] = [1 1] @m + [1] [0 1] [1] >= [1 1] @m + [1] [0 1] [1] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 0] @m + [0] [1 1] [0 1] [0] >= [1 0] @base + [1 0] @m + [0] [1 1] [0 1] [0] = [transAcc#1(@m, @base)] [mkBase#1(::(@l, @m'))] = [1 1] @l + [1 1] @m' + [2] [0 0] [0 1] [2] >= [1 1] @m' + [2] [0 1] [2] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [2] [1] > [1] [0] = [nil()] [split(@m)] = [1 0] @m + [0] [1 0] [1] >= [1 0] @m + [0] [1 0] [1] = [split#1(@m)] [split#1(::(@l, @ls))] = [1 1] @l + [1 0] @ls + [0] [1 1] [1 0] [1] >= [0 1] @l + [1 0] @ls + [0] [1 1] [1 0] [1] = [split#2(@l, @ls)] [split#1(nil())] = [1] [2] > [0] [2] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [1 0] @ls + [0 0] @x + [0 1] @xs + [1] [1 0] [1 1] [1 1] [2] >= [1 0] @ls + [0 0] @x + [0 0] @xs + [1] [1 0] [1 1] [1 1] [2] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [1 0] @ls + [0] [1 0] [2] >= [0] [2] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1] [1 1] [1 1] [1 1] [0 0] [2] >= [0 0] @m' + [0 0] @xs + [0 1] @ys + [1] [1 1] [1 1] [0 0] [2] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 0] @m' + [0] [1 1] [0 0] [0 1] [1] >= [1 0] @base + [1 1] @l + [1 0] @m' + [0] [1 1] [0 0] [0 1] [1] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [1] [1 1] [0] > [1 0] @base + [0] [0 1] [0] = [@base] [lineMult^#(@l, @m2)] = [0] [0] >= [0] [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0] [0] >= [0] [0] = [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_3(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_4(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [0] [0] >= [0] [0] = [c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult'^#(@m1, @m2)] = [0] [0] >= [0] [0] = [c_5(matrixMult'#1^#(@m1, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0] [0] >= [0] [0] = [c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 0] @m3 + [1] [1 1] [1 1] [1 1] [1] >= [1] [1] = [c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2))] [matrixMultList^#(@acc, @mm)] = [0] [0] >= [0] [0] = [c_17(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [0] [0] >= [0] [0] = [c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m))] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 1] @m2 + [1] [1 1] [1 1] [1] >= [1 1] @m2 + [1] [0 0] [1] = [c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))] [transpose^#(@m)] = [1 1] @m + [1] [0 0] [0] >= [1 1] @m + [1] [0 0] [0] = [c_7(transpose#1^#(@m, @m))] [transpose#1^#(::(@xs, @xss), @m)] = [1 1] @m + [1] [0 0] [0] >= [1 1] @m + [1] [0 0] [0] = [c_8(transpose#2^#(split(@m)), split^#(@m))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0] [0] >= [0] [0] = [c_9(mult^#(@xs, @ys))] [split^#(@m)] = [0 1] @m + [0] [1 0] [0] >= [0 1] @m + [0] [0 0] [0] = [c_10(split#1^#(@m))] [split#1^#(::(@l, @ls))] = [0 1] @ls + [1] [0 0] [0] > [0 1] @ls + [0] [0 0] [0] = [c_11(split#2^#(@l, @ls))] [split#2^#(::(@x, @xs), @ls)] = [0 1] @ls + [0] [0 0] [0] >= [0 1] @ls + [0] [0 0] [0] = [c_12(split^#(@ls))] [transpose#2^#(tuple#2(@l, @m'))] = [0 0] @l + [1 1] @m' + [1] [0 1] [1 1] [1] >= [1 1] @m' + [1] [0 0] [0] = [c_13(transpose#3^#(@m', @l))] [transpose#3^#(::(@y, @ys), @l)] = [1 1] @y + [1 1] @ys + [2] [0 0] [0 0] [0] >= [1 1] @y + [1 1] @ys + [2] [0 0] [0 0] [0] = [c_14(transpose^#(::(@y, @ys)))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , 6: matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 7: transpose^#(@m) -> c_7(transpose#1^#(@m, @m)) , 8: transpose#1^#(::(@xs, @xss), @m) -> c_8(transpose#2^#(split(@m)), split^#(@m)) , 9: mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) , 10: split^#(@m) -> c_10(split#1^#(@m)) , 11: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) , 12: split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) , 13: transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , 14: transpose#3^#(::(@y, @ys), @l) -> c_14(transpose^#(::(@y, @ys))) , 15: matrixMult^#(@m1, @m2) -> c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 16: matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 17: matrixMultList^#(@acc, @mm) -> c_17(matrixMultList#1^#(@mm, @acc)) , 18: matrixMultList#1^#(::(@m, @ms), @acc) -> c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 19: matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {11}. These cover all (indirect) predecessors of dependency pairs {11,12,16,19}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , transpose^#(@m) -> c_7(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_8(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) , split^#(@m) -> c_10(split#1^#(@m)) , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_14(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_17(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 11: transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , 14: matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 18: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) } Trs: { lineMult#1(nil(), @l) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1, 2}, Uargs(c_17) = {1}, Uargs(c_18) = {1, 2}, Uargs(c_19) = {1, 2} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [1 0] x1 + [0] [0 1] [0] [#pos](x1) = [1 0] x1 + [0] [0 1] [0] [#s](x1) = [1 0] x1 + [0] [1 0] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [0] [0] [#add](x1, x2) = [0] [0] [attach](x1, x2) = [0 0] x2 + [0] [0 1] [1] [attach#1](x1, x2) = [0 0] x1 + [2 0] x2 + [0] [0 1] [2 2] [2] [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 0] [0 1] [0] [attach#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0] [2 2] [0 0] [2] [nil] = [0] [0] [lineMult](x1, x2) = [2] [0] [lineMult#1](x1, x2) = [0 0] x2 + [2] [0 2] [0] [mult](x1, x2) = [2] [0] [makeBase](x1) = [2 0] x1 + [0] [1 2] [2] [makeBase#1](x1) = [0] [0] [mkBase](x1) = [0] [0] [matrixMult](x1, x2) = [0] [0] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [matrixMult'](x1, x2) = [0] [0] [matrixMult'#1](x1, x2) = [2 0] x2 + [0] [0 0] [0] [transpose](x1) = [0] [0] [mkBase#1](x1) = [2] [2] [mult#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [mult#2](x1, x2, x3) = [2 0] x2 + [0] [2 0] [0] [split](x1) = [0 2] x1 + [2] [0 1] [1] [split#1](x1) = [0 1] x1 + [2] [0 1] [1] [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [2] [1 0] [0 1] [1] [tuple#2](x1, x2) = [0 0] x2 + [2] [1 1] [1] [split#3](x1, x2, x3) = [0 1] x1 + [0 0] x3 + [1] [0 1] [1 0] [1] [transAcc#1](x1, x2) = [2 0] x2 + [0] [0 2] [0] [transpose#1](x1, x2) = [0] [0] [transpose#2](x1) = [1 0] x1 + [0] [0 0] [0] [transpose#3](x1, x2) = [0 0] x2 + [2] [2 0] [2] [#pred](x1) = [0] [0] [#succ](x1) = [0 0] x1 + [0] [2 0] [0] [#natmult](x1, x2) = [0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0 0] x2 + [0] [1 0] [0] [lineMult#1^#](x1, x2) = [0 0] x2 + [0] [2 2] [0] [mult^#](x1, x2) = [0 0] x2 + [0] [1 1] [1] [mult#1^#](x1, x2) = [0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [0] [0] [matrixMult'^#](x1, x2) = [0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0 0] x2 + [0] [2 2] [0] [matrixMult3^#](x1, x2, x3) = [2 0] x1 + [2 0] x2 + [1 0] x3 + [2] [2 2] [1 1] [1 1] [2] [matrixMultList^#](x1, x2) = [0] [0] [matrixMultList#1^#](x1, x2) = [0 0] x2 + [0] [2 2] [0] [matrixMultOld^#](x1, x2) = [2 0] x1 + [1 2] x2 + [2] [2 1] [1 2] [2] [transpose^#](x1) = [1 2] x1 + [2] [0 0] [0] [transpose#1^#](x1, x2) = [1 2] x2 + [2] [0 0] [1] [mult#2^#](x1, x2, x3) = [0] [0] [split^#](x1) = [1 0] x1 + [0] [1 0] [1] [split#1^#](x1) = [1 0] x1 + [0] [0 0] [1] [split#2^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0 2] x1 + [0] [0 1] [0] [transpose#3^#](x1, x2) = [2 2] x1 + [1] [0 0] [1] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1, x2) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1, x2, x3) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1) = [0] [0] [c_15](x1, x2) = [0] [0] [c_16](x1, x2) = [0] [0] [c_17](x1, x2) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1, x2) = [0] [0] [c_20](x1, x2) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1, x2) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1) = [0] [0] [c_25](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] [c_28](x1) = [0] [0] [c_29](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [0] [0] [c_2](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1, x2) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1, x2) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1) = [0] [0] [c_21](x1, x2, x3) = [0] [0] [c_22](x1, x2) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1, x2) = [0] [0] [c_25](x1, x2) = [0] [0] [c_26](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [0] [0] [c_2](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1, x2) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1, x2) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1, x2) = [0] [0] [c_18](x1, x2) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1, x2) = [0] [0] [c_21](x1, x2) = [0] [0] [c_22](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 1] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] [c_11](x1) = [1 1] x1 + [0] [0 0] [0] [c_12](x1) = [1 0] x1 + [0] [0 0] [0] [c_13](x1) = [1 0] x1 + [0] [0 0] [0] [c_14](x1) = [1 1] x1 + [0] [0 0] [0] [c_15](x1) = [2 0] x1 + [0] [0 0] [0] [c_16](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [1] [c_17](x1) = [1 0] x1 + [0] [0 0] [0] [c_18](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_19](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] This order satisfies following ordering constraints [split(@m)] = [0 2] @m + [2] [0 1] [1] >= [0 1] @m + [2] [0 1] [1] = [split#1(@m)] [split#1(::(@l, @ls))] = [1 0] @l + [0 1] @ls + [2] [1 0] [0 1] [1] >= [0 0] @l + [0 1] @ls + [2] [1 0] [0 1] [1] = [split#2(@l, @ls)] [split#1(nil())] = [2] [1] >= [2] [1] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [0 1] @ls + [0 0] @xs + [2] [0 1] [1 0] [2] >= [0 1] @ls + [0 0] @xs + [2] [0 1] [1 0] [2] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [0 1] @ls + [2] [0 1] [1] >= [2] [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [1 1] @m' + [0 0] @xs + [2] [1 1] [1 0] [2] >= [0 0] @m' + [0 0] @xs + [2] [1 1] [1 0] [2] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [lineMult^#(@l, @m2)] = [0 0] @m2 + [0] [1 0] [0] >= [0] [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0 0] @l + [0] [2 2] [0] >= [0] [0] = [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0 0] @l2 + [0] [1 1] [1] >= [0] [0] = [c_3(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_4(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [0] [0] >= [0] [0] = [c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult'^#(@m1, @m2)] = [0] [0] >= [0] [0] = [c_5(matrixMult'#1^#(@m1, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 0] @m2 + [0] [2 2] [0] >= [0] [0] = [c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [2 0] @m1 + [2 0] @m2 + [1 0] @m3 + [2] [2 2] [1 1] [1 1] [2] > [0] [1] = [c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2))] [matrixMultList^#(@acc, @mm)] = [0] [0] >= [0] [0] = [c_17(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [0 0] @acc + [0] [2 2] [0] >= [0] [0] = [c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m))] [matrixMultOld^#(@m1, @m2)] = [2 0] @m1 + [1 2] @m2 + [2] [2 1] [1 2] [2] >= [1 2] @m2 + [2] [0 0] [0] = [c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))] [transpose^#(@m)] = [1 2] @m + [2] [0 0] [0] >= [1 2] @m + [2] [0 0] [0] = [c_7(transpose#1^#(@m, @m))] [transpose#1^#(::(@xs, @xss), @m)] = [1 2] @m + [2] [0 0] [1] >= [1 2] @m + [2] [0 0] [0] = [c_8(transpose#2^#(split(@m)), split^#(@m))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0] [0] >= [0] [0] = [c_9(mult^#(@xs, @ys))] [split^#(@m)] = [1 0] @m + [0] [1 0] [1] >= [1 0] @m + [0] [0 0] [0] = [c_10(split#1^#(@m))] [split#1^#(::(@l, @ls))] = [1 0] @ls + [1] [0 0] [1] > [1 0] @ls + [0] [0 0] [0] = [c_11(split#2^#(@l, @ls))] [split#2^#(::(@x, @xs), @ls)] = [1 0] @ls + [0] [0 0] [0] >= [1 0] @ls + [0] [0 0] [0] = [c_12(split^#(@ls))] [transpose#2^#(tuple#2(@l, @m'))] = [2 2] @m' + [2] [1 1] [1] > [2 2] @m' + [1] [0 0] [0] = [c_13(transpose#3^#(@m', @l))] [transpose#3^#(::(@y, @ys), @l)] = [2 0] @y + [2 2] @ys + [3] [0 0] [0 0] [1] >= [2 0] @y + [1 2] @ys + [3] [0 0] [0 0] [0] = [c_14(transpose^#(::(@y, @ys)))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , 6: matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 7: transpose^#(@m) -> c_7(transpose#1^#(@m, @m)) , 8: transpose#1^#(::(@xs, @xss), @m) -> c_8(transpose#2^#(split(@m)), split^#(@m)) , 9: mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) , 10: split^#(@m) -> c_10(split#1^#(@m)) , 11: transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , 12: transpose#3^#(::(@y, @ys), @l) -> c_14(transpose^#(::(@y, @ys))) , 13: matrixMult^#(@m1, @m2) -> c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 14: matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 15: matrixMultList^#(@acc, @mm) -> c_17(matrixMultList#1^#(@mm, @acc)) , 16: matrixMultList#1^#(::(@m, @ms), @acc) -> c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 17: matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 18: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) , 19: split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {11,14,18}. These cover all (indirect) predecessors of dependency pairs {7,8,10,11,12,14,17,18,19}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_17(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_7(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_8(transpose#2^#(split(@m)), split^#(@m)) , split^#(@m) -> c_10(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_14(transpose^#(::(@y, @ys))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { transpose^#(@m) -> c_7(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_8(transpose#2^#(split(@m)), split^#(@m)) , split^#(@m) -> c_10(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_14(transpose^#(::(@y, @ys))) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> c_16(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_17(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_18(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMultOld^#(@m1, @m2) -> c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> c_9(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_10(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We decompose the input problem according to the dependency graph into the upper component { matrixMult3^#(@m1, @m2, @m3) -> c_9(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_10(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transpose(@m2))) } and lower component { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Further, following extension rules are added to the lower component. { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult3^#(@m1, @m2, @m3) -> c_9(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transpose(@m2))) } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_10(matrixMultList#1^#(@mm, @acc)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult3^#(@m1, @m2, @m3) -> c_9(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transpose(@m2))) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult3^#(@m1, @m2, @m3) -> c_1() , matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_3() } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Consider the dependency graph 1: matrixMult3^#(@m1, @m2, @m3) -> c_1() 2: matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) -->_1 matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) :4 3: matrixMultOld^#(@m1, @m2) -> c_3() 4: matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) :2 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { matrixMult3^#(@m1, @m2, @m3) -> c_1() , matrixMultOld^#(@m1, @m2) -> c_3() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We replace rewrite rules by usable rules: Weak Usable Rules: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 1: matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Trs: { attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base } Sub-proof: ---------- The following argument positions are usable: Uargs(c_2) = {1}, Uargs(c_4) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [0] [#pos](x1) = [0] [#s](x1) = [0] [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x2 + [1] [attach#2](x1, x2, x3) = [0] [nil] = [0] [lineMult](x1, x2) = [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [0] [makeBase#1](x1) = [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [1] x1 + [1] [transAcc](x1, x2) = [0] [matrixMult'](x1, x2) = [0] [matrixMult'#1](x1, x2) = [1] x1 + [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [1] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x2 + [1] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [1] x2 + [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [0] [matrixMultList^#](x1, x2) = [1] x2 + [0] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [0] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_9](x1, x2) = [0] [c_10](x1) = [0] [c_11](x1, x2) = [0] [c_12](x1) = [0] [c] = [0] [c_1] = [0] [c_2](x1) = [1] x1 + [0] [c_3] = [0] [c_4](x1) = [1] x1 + [0] This order satisfies following ordering constraints [#natmult(#0(), @y)] = [0] >= [0] = [#0()] [#natmult(#s(@x), @y)] = [0] >= [0] = [#natadd(@y, #natmult(@x, @y))] [#natadd(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#natadd(#s(@x), @y)] = [1] @y + [0] >= [0] = [#s(#natadd(@x, @y))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [0] >= [1] @mm + [0] = [c_4(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @ms + [1] > [1] @ms + [0] = [c_2(matrixMultList^#(matrixMult(@acc, @m), @ms))] Consider the set of all dependency pairs DPs: { 1: matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 2: matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {1}. These cover all (indirect) predecessors of dependency pairs {1,2}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) Consider the dependency graph 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) -->_1 lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) :2 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) -->_1 mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) :3 -->_2 lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) :1 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) -->_1 mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) :4 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) -->_1 mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) :7 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) -->_1 matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6 6: matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) -->_2 matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) :5 -->_1 lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) :1 7: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) -->_1 mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) :3 8: matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) -->_1 matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) :5 9: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) -->_1 matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) :8 10: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) -->_1 matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) :8 11: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) :13 -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) :12 12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) -->_1 matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) :8 13: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) -->_1 matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) :11 14: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) -->_1 matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) :5 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We decompose the input problem according to the dependency graph into the upper component { matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } and lower component { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Further, following extension rules are added to the lower component. { matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult3^#(@m1, @m2, @m3) -> c_4(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_6(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_7(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2)) , 4: matrixMult3^#(@m1, @m2, @m3) -> c_4(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 6: matrixMultList#1^#(::(@m, @ms), @acc) -> c_6(matrixMult^#(@acc, @m)) } Trs: { transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [1] x1 + [0] [#pos](x1) = [0] [#s](x1) = [0] [*](x1, x2) = [0] [#mult](x1, x2) = [1] x1 + [0] [+](x1, x2) = [1] x1 + [1] x2 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [0] [::](x1, x2) = [1] x2 + [1] [attach#2](x1, x2, x3) = [0] [nil] = [0] [lineMult](x1, x2) = [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [0] [makeBase#1](x1) = [0] [mkBase](x1) = [0] [matrixMult](x1, x2) = [1] x1 + [0] [transAcc](x1, x2) = [1] [matrixMult'](x1, x2) = [1] x1 + [0] [matrixMult'#1](x1, x2) = [1] x1 + [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [0] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [1] x2 + [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x2 + [1] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [1] x1 + [0] [matrixMult'^#](x1, x2) = [1] x1 + [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [1] x1 + [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x1 + [1] [matrixMultList#1^#](x1, x2) = [1] x2 + [1] [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_5](x1) = [0] [c_6](x1, x2) = [0] [c_8](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [1] This order satisfies following ordering constraints [matrixMult(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))] [matrixMult'(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [matrixMult'#1(@m1, @m2)] [matrixMult'#1(::(@l, @ls), @m2)] = [1] @ls + [1] >= [1] @ls + [1] = [::(lineMult(@l, @m2), matrixMult'(@ls, @m2))] [matrixMult'#1(nil(), @m2)] = [0] >= [0] = [nil()] [matrixMult^#(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult'^#(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [c_1(matrixMult'#1^#(@m1, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1] @ls + [1] > [1] @ls + [0] = [c_2(matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] > [1] @m1 + [0] = [c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1] @acc + [1] >= [1] @acc + [1] = [c_5(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @acc + [1] > [1] @acc + [0] = [c_6(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @acc + [1] >= [1] @acc + [1] = [c_7(matrixMultList^#(matrixMult(@acc, @m), @ms))] [matrixMultOld^#(@m1, @m2)] = [1] @m1 + [1] @m2 + [1] >= [1] @m1 + [1] = [c_8(matrixMult'^#(@m1, transpose(@m2)))] Consider the set of all dependency pairs DPs: { 1: matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2)) , 2: matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2)) , 3: matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 4: matrixMult3^#(@m1, @m2, @m3) -> c_4(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 5: matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc)) , 6: matrixMultList#1^#(::(@m, @ms), @acc) -> c_6(matrixMult^#(@acc, @m)) , 7: matrixMultList#1^#(::(@m, @ms), @acc) -> c_7(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 8: matrixMultOld^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transpose(@m2))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,4,6}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4,6,8}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_4(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_6(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_7(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_4(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_6(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_7(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_8(matrixMult'^#(@m1, transpose(@m2))) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 5: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) , 10: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) } Trs: { attach#2(nil(), @x, @xs) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , transpose#1(nil(), @m) -> nil() , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_7) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0 0] x1 + [0] [1 0] [0] [#neg](x1) = [1 1] x1 + [0] [0 0] [0] [#pos](x1) = [0 1] x1 + [0] [1 0] [0] [#s](x1) = [0 1] x1 + [0] [1 0] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [0] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [0] [nil] = [0] [0] [lineMult](x1, x2) = [0 1] x2 + [1] [0 1] [1] [lineMult#1](x1, x2) = [1 1] x1 + [0] [0 1] [1] [mult](x1, x2) = [0 0] x2 + [1] [1 0] [0] [makeBase](x1) = [0 1] x1 + [0] [1 0] [0] [makeBase#1](x1) = [0 1] x1 + [0] [1 0] [0] [mkBase](x1) = [0 0] x1 + [0] [0 1] [0] [matrixMult](x1, x2) = [0 1] x1 + [0] [0 1] [0] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [1 1] [0] [matrixMult'](x1, x2) = [0 1] x1 + [0] [0 1] [0] [matrixMult'#1](x1, x2) = [0 0] x1 + [0] [0 1] [0] [transpose](x1) = [1 1] x1 + [1] [1 0] [0] [mkBase#1](x1) = [0 0] x1 + [0] [0 1] [0] [mult#1](x1, x2) = [1 1] x1 + [0] [0 1] [0] [mult#2](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [0] [1 0] [1 0] [0] [split](x1) = [1 0] x1 + [0] [0 1] [0] [split#1](x1) = [1 0] x1 + [0] [0 1] [0] [split#2](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [tuple#2](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 1] [0 0] [0] [split#3](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [1] [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [1 1] [0] [transpose#1](x1, x2) = [1 1] x2 + [1] [1 0] [0] [transpose#2](x1) = [1 1] x1 + [1] [1 0] [0] [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [1] [1 1] [0 0] [0] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [lineMult#1^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [mult^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [mult#1^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [1 1] x2 + [0] [0 0] [0] [matrixMult'^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [1 0] x2 + [1] [0 0] [1] [matrixMultList#1^#](x1, x2) = [1 0] x1 + [1] [0 0] [1] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [0 1] x1 + [0] [0 1] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [1 1] x1 + [0] [0 0] [0] [c_2](x1, x2) = [1 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_3](x1) = [1 1] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 1] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] >= [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] >= [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [0] [0 1] [0] >= [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [1] [0 0] [0 0] [0] > [0] [0] = [nil()] [makeBase(@m)] = [0 1] @m + [0] [1 0] [0] >= [0 1] @m + [0] [1 0] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [0 0] @l + [0 1] @m' + [1] [1 1] [1 0] [0] > [0 0] @l + [0] [0 1] [0] = [mkBase(@l)] [makeBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [mkBase(@m)] = [0 0] @m + [0] [0 1] [0] >= [0 0] @m + [0] [0 1] [0] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 0] @m + [0] [1 1] [0 0] [0] >= [1 0] @base + [1 0] @m + [0] [1 1] [0 0] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [1] [1 0] [0] >= [1 1] @m + [1] [1 0] [0] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [0 0] @m' + [0] [0 1] [1] >= [0 0] @m' + [0] [0 1] [1] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [split(@m)] = [1 0] @m + [0] [0 1] [0] >= [1 0] @m + [0] [0 1] [0] = [split#1(@m)] [split#1(::(@l, @ls))] = [1 1] @l + [1 0] @ls + [0] [0 0] [0 1] [1] >= [1 1] @l + [1 0] @ls + [0] [0 0] [0 1] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [0] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] >= [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [1 0] @ls + [0] [0 1] [1] >= [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1] [0 0] [0 0] [0 0] [0 1] [1] >= [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1] [0 0] [0 0] [0 0] [0 1] [1] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 0] @m' + [0] [1 1] [0 0] [0 0] [0] >= [1 0] @base + [1 1] @l + [1 0] @m' + [0] [1 1] [0 0] [0 0] [0] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [1 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [1 1] @m + [1] [1 0] [0] >= [1 1] @m + [1] [1 0] [0] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [1 1] @m + [1] [1 0] [0] > [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [1 1] @l + [1 1] @m' + [1] [1 0] [1 1] [0] >= [1 1] @l + [1 1] @m' + [1] [0 0] [1 1] [0] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 1] [1] >= [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 0] [1] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [1 1] @l + [1] [0 0] [0] > [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [1 1] @x + [1 0] @xs + [0] [0 0] [0 0] [0] >= [0 1] @x + [1 0] @xs + [0] [0 0] [0 0] [0] = [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0 1] @l2 + [0] [0 0] [0] >= [0 1] @l2 + [0] [0 0] [0] = [c_3(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0 1] @l2 + [0] [0 0] [0] >= [0 1] @l2 + [0] [0 0] [0] = [c_4(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [1 1] @m2 + [0] [0 0] [0] >= [1 1] @m2 + [0] [0 0] [0] = [matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))] [matrixMult'^#(@m1, @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [matrixMult'#1^#(@m1, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [lineMult^#(@l, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [matrixMult'^#(@ls, @m2)] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1] [1 1] [1 1] [1 1] [1] > [1 1] @m3 + [0] [0 0] [0] = [matrixMult^#(matrixMult(@m1, @m2), @m3)] [matrixMultList^#(@acc, @mm)] = [1 0] @mm + [1] [0 0] [1] >= [1 0] @mm + [1] [0 0] [1] = [matrixMultList#1^#(@mm, @acc)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 0] @ms + [1] [0 0] [0 0] [1] > [1 1] @m + [0] [0 0] [0] = [matrixMult^#(@acc, @m)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 0] @ms + [1] [0 0] [0 0] [1] >= [1 0] @ms + [1] [0 0] [1] = [matrixMultList^#(matrixMult(@acc, @m), @ms)] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 1] @m2 + [1] [1 1] [1 1] [1] >= [1 1] @m2 + [1] [0 0] [0] = [matrixMult'^#(@m1, transpose(@m2))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0 1] @ys + [1] [0 1] [1] > [0 1] @ys + [0] [0 0] [0] = [c_7(mult^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , 5: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) , 6: matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , 7: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , 8: matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , 9: matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , 10: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , 11: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , 13: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , 14: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {5,10,12}. These cover all (indirect) predecessors of dependency pairs {5,6,10,12,14}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) } Weak DPs: { matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 5: matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , 11: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) } Trs: { attach#2(nil(), @x, @xs) -> nil() , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , transpose#1(nil(), @m) -> nil() , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_7) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [1 0] x1 + [0] [0 1] [0] [#pos](x1) = [1 0] x1 + [0] [0 0] [0] [#s](x1) = [1 0] x1 + [0] [0 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [0] [0] [#add](x1, x2) = [0] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [2] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [2] [0 1] [0 0] [0 0] [0] [nil] = [0] [0] [lineMult](x1, x2) = [0 0] x2 + [0] [0 1] [0] [lineMult#1](x1, x2) = [0 0] x1 + [0 0] x2 + [0] [0 1] [2 2] [0] [mult](x1, x2) = [0] [2] [makeBase](x1) = [0 0] x1 + [0] [1 0] [1] [makeBase#1](x1) = [0 0] x1 + [0] [1 0] [1] [mkBase](x1) = [0 0] x1 + [0] [0 1] [0] [matrixMult](x1, x2) = [0 0] x1 + [2 2] x2 + [2] [0 1] [0 0] [0] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [matrixMult'](x1, x2) = [0 0] x1 + [0 2] x2 + [0] [0 1] [0 0] [0] [matrixMult'#1](x1, x2) = [0 0] x1 + [2 2] x2 + [0] [0 1] [2 2] [0] [transpose](x1) = [1 1] x1 + [2] [1 1] [0] [mkBase#1](x1) = [0 0] x1 + [0] [0 1] [0] [mult#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [mult#2](x1, x2, x3) = [0 0] x2 + [0] [0 2] [0] [split](x1) = [0 1] x1 + [0] [1 0] [2] [split#1](x1) = [0 1] x1 + [0] [1 0] [2] [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [2] [1 1] [1 0] [2] [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0] [1 0] [1 1] [2] [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [2] [0 1] [1 1] [1 1] [2] [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [transpose#1](x1, x2) = [0 0] x1 + [1 1] x2 + [2] [0 1] [1 0] [0] [transpose#2](x1) = [1 1] x1 + [0] [0 1] [0] [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [2] [1 1] [1 0] [2] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [1 1] x2 + [0] [0 0] [0] [lineMult#1^#](x1, x2) = [1 1] x1 + [0] [0 0] [0] [mult^#](x1, x2) = [0 1] x2 + [2] [1 0] [2] [mult#1^#](x1, x2) = [0 1] x2 + [0] [0 0] [1] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [2 2] x2 + [2] [0 0] [0] [matrixMult'^#](x1, x2) = [1 1] x2 + [0] [0 0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [1 1] x2 + [0] [0 0] [0] [matrixMult3^#](x1, x2, x3) = [2 0] x1 + [1 0] x2 + [2 2] x3 + [2] [2 2] [1 1] [2 2] [2] [matrixMultList^#](x1, x2) = [2 2] x2 + [0] [0 0] [0] [matrixMultList#1^#](x1, x2) = [2 2] x1 + [0] [0 0] [0] [matrixMultOld^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2] [2 2] [2 2] [2] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [0 1] x1 + [0] [0 0] [1] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_3](x1) = [1 1] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] >= [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [2] [0 1] [0 0] [0 0] [0] >= [1 0] @m + [1 1] @x + [1 1] @xs + [2] [0 1] [0 0] [0 0] [0] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [0] [0 1] [0] >= [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [2] [0 0] [0 1] [0 0] [0 0] [2] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [2] [0 0] [0 1] [0 0] [0 0] [2] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [2] [0 0] [0 0] [0] > [0] [0] = [nil()] [makeBase(@m)] = [0 0] @m + [0] [1 0] [1] >= [0 0] @m + [0] [1 0] [1] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [0 0] @l + [0 0] @m' + [0] [1 1] [1 0] [1] >= [0 0] @l + [0] [0 1] [0] = [mkBase(@l)] [makeBase#1(nil())] = [0] [1] >= [0] [0] = [nil()] [mkBase(@m)] = [0 0] @m + [0] [0 1] [0] >= [0 0] @m + [0] [0 1] [0] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 0] @m + [0] [0 1] [0 1] [0] >= [1 0] @base + [1 0] @m + [0] [0 1] [0 1] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [2] [1 1] [0] >= [1 1] @m + [2] [1 1] [0] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [0 0] @m' + [0] [0 1] [2] >= [0 0] @m' + [0] [0 1] [2] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [split(@m)] = [0 1] @m + [0] [1 0] [2] >= [0 1] @m + [0] [1 0] [2] = [split#1(@m)] [split#1(::(@l, @ls))] = [0 0] @l + [0 1] @ls + [2] [1 1] [1 0] [2] >= [0 0] @l + [0 1] @ls + [2] [1 1] [1 0] [2] = [split#2(@l, @ls)] [split#1(nil())] = [0] [2] >= [0] [2] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [0 1] @ls + [0 0] @x + [0 0] @xs + [2] [1 0] [1 1] [1 1] [4] >= [0 1] @ls + [0 0] @x + [0 0] @xs + [2] [1 0] [1 1] [1 1] [4] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [0 1] @ls + [2] [1 0] [2] > [0] [2] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [2] [1 1] [1 1] [1 1] [1 0] [4] >= [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [2] [1 1] [1 1] [1 1] [1 0] [4] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 0] @m' + [0] [0 1] [0 0] [0 1] [2] >= [1 0] @base + [1 1] @l + [1 0] @m' + [0] [0 1] [0 0] [0 1] [0] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [0 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [1 1] @m + [0 0] @xss + [2] [1 0] [0 1] [2] >= [1 1] @m + [2] [1 0] [2] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [1 1] @m + [2] [1 0] [0] > [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [1 1] @l + [1 1] @m' + [2] [1 0] [1 1] [2] >= [1 1] @l + [1 1] @m' + [2] [1 0] [1 1] [2] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [1 1] @l + [1 1] @y + [1 1] @ys + [4] [1 0] [1 1] [1 1] [4] >= [1 1] @l + [1 1] @y + [1 1] @ys + [4] [0 0] [1 1] [1 1] [4] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [1 1] @l + [2] [1 0] [2] > [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [1 1] @m2 + [0] [0 0] [0] >= [1 1] @m2 + [0] [0 0] [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [1 1] @x + [1 1] @xs + [2] [0 0] [0 0] [0] >= [0 1] @x + [1 1] @xs + [2] [0 0] [0 0] [0] = [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))] [mult^#(@l1, @l2)] = [0 1] @l2 + [2] [1 0] [2] > [0 1] @l2 + [1] [0 0] [0] = [c_3(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0 1] @l2 + [0] [0 0] [1] >= [0 1] @l2 + [0] [0 0] [0] = [c_4(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [2 2] @m2 + [2] [0 0] [0] > [2 1] @m2 + [1] [0 0] [0] = [matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))] [matrixMult'^#(@m1, @m2)] = [1 1] @m2 + [0] [0 0] [0] >= [1 1] @m2 + [0] [0 0] [0] = [matrixMult'#1^#(@m1, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1 1] @m2 + [0] [0 0] [0] >= [1 1] @m2 + [0] [0 0] [0] = [lineMult^#(@l, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1 1] @m2 + [0] [0 0] [0] >= [1 1] @m2 + [0] [0 0] [0] = [matrixMult'^#(@ls, @m2)] [matrixMult3^#(@m1, @m2, @m3)] = [2 0] @m1 + [1 0] @m2 + [2 2] @m3 + [2] [2 2] [1 1] [2 2] [2] >= [2 2] @m3 + [2] [0 0] [0] = [matrixMult^#(matrixMult(@m1, @m2), @m3)] [matrixMultList^#(@acc, @mm)] = [2 2] @mm + [0] [0 0] [0] >= [2 2] @mm + [0] [0 0] [0] = [matrixMultList#1^#(@mm, @acc)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [2 2] @m + [2 2] @ms + [4] [0 0] [0 0] [0] > [2 2] @m + [2] [0 0] [0] = [matrixMult^#(@acc, @m)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [2 2] @m + [2 2] @ms + [4] [0 0] [0 0] [0] > [2 2] @ms + [0] [0 0] [0] = [matrixMultList^#(matrixMult(@acc, @m), @ms)] [matrixMultOld^#(@m1, @m2)] = [2 2] @m1 + [2 2] @m2 + [2] [2 2] [2 2] [2] >= [2 2] @m2 + [2] [0 0] [0] = [matrixMult'^#(@m1, transpose(@m2))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0 1] @ys + [2] [0 0] [1] >= [0 1] @ys + [2] [0 0] [0] = [c_7(mult^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , 5: matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , 6: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , 7: matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , 8: matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , 9: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , 10: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , 11: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , 13: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , 14: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3,5,11,12}. These cover all (indirect) predecessors of dependency pairs {3,4,5,9,10,11,12,13,14}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) } Weak DPs: { mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) } Weak DPs: { matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { lineMult#1^#(::(@x, @xs), @l) -> c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_7(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_11(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , 3: matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 9: matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , 10: matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Trs: { attach#2(nil(), @x, @xs) -> nil() , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [0 0] x1 + [0] [0 1] [0] [#pos](x1) = [0 0] x1 + [0] [0 1] [0] [#s](x1) = [0 1] x1 + [0] [0 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [0] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [0] [nil] = [0] [0] [lineMult](x1, x2) = [1 0] x1 + [0 1] x2 + [1] [0 0] [0 0] [0] [lineMult#1](x1, x2) = [0 1] x1 + [1] [1 1] [0] [mult](x1, x2) = [0 0] x1 + [1] [1 0] [0] [makeBase](x1) = [1 1] x1 + [1] [1 1] [0] [makeBase#1](x1) = [0 1] x1 + [1] [1 1] [0] [mkBase](x1) = [0 0] x1 + [0] [0 1] [0] [matrixMult](x1, x2) = [1 0] x1 + [0] [1 0] [0] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [matrixMult'](x1, x2) = [1 0] x1 + [1] [1 0] [0] [matrixMult'#1](x1, x2) = [0 0] x1 + [1 0] x2 + [0] [1 0] [0 1] [0] [transpose](x1) = [1 1] x1 + [0] [1 0] [1] [mkBase#1](x1) = [0 0] x1 + [0] [0 1] [0] [mult#1](x1, x2) = [0] [0] [mult#2](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [0] [1 0] [0 1] [0] [split](x1) = [1 0] x1 + [0] [0 1] [0] [split#1](x1) = [1 0] x1 + [0] [0 1] [0] [split#2](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [tuple#2](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 1] [0 0] [0] [split#3](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [1] [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [transpose#1](x1, x2) = [1 1] x2 + [0] [1 0] [1] [transpose#2](x1) = [1 1] x1 + [0] [1 0] [1] [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [0] [1 1] [0 0] [1] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0 0] x1 + [0] [0 1] [0] [#natadd](x1, x2) = [0 0] x2 + [0] [0 1] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0 1] x2 + [0] [1 1] [1] [lineMult#1^#](x1, x2) = [0 1] x1 + [0] [1 0] [1] [mult^#](x1, x2) = [0] [0] [mult#1^#](x1, x2) = [0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [1 1] x2 + [1] [0 0] [0] [matrixMult'^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0 0] x1 + [0 1] x2 + [0] [1 0] [1 1] [0] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [1 1] x2 + [1] [0 0] [0] [matrixMultList#1^#](x1, x2) = [1 1] x1 + [1] [0 1] [1] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 0] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_7](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [1] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 1] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [1] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] [c_9](x1) = [1 1] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] [c_11](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] >= [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] >= [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [0] [0 1] [0] >= [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [1] [0 0] [0 0] [0] > [0] [0] = [nil()] [makeBase(@m)] = [1 1] @m + [1] [1 1] [0] >= [0 1] @m + [1] [1 1] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [0 0] @l + [0 1] @m' + [2] [1 1] [1 1] [1] > [0 0] @l + [0] [0 1] [0] = [mkBase(@l)] [makeBase#1(nil())] = [1] [0] > [0] [0] = [nil()] [mkBase(@m)] = [0 0] @m + [0] [0 1] [0] >= [0 0] @m + [0] [0 1] [0] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 0] @m + [0] [0 1] [0 0] [0] >= [1 0] @base + [1 0] @m + [0] [0 1] [0 0] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [0] [1 0] [1] >= [1 1] @m + [0] [1 0] [1] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [0 0] @m' + [0] [0 1] [1] >= [0 0] @m' + [0] [0 1] [1] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [split(@m)] = [1 0] @m + [0] [0 1] [0] >= [1 0] @m + [0] [0 1] [0] = [split#1(@m)] [split#1(::(@l, @ls))] = [1 1] @l + [1 0] @ls + [0] [0 0] [0 1] [1] >= [1 1] @l + [1 0] @ls + [0] [0 0] [0 1] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [0] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] >= [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [1 0] @ls + [0] [0 1] [1] >= [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1] [0 0] [0 0] [0 0] [0 1] [1] >= [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1] [0 0] [0 0] [0 0] [0 1] [1] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 0] @m' + [0] [0 1] [0 0] [0 0] [0] >= [1 0] @base + [1 1] @l + [1 0] @m' + [0] [0 1] [0 0] [0 0] [0] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [0 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [1 1] @m + [0] [1 0] [1] >= [1 1] @m + [0] [1 0] [1] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [1 1] @m + [0] [1 0] [1] >= [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [1 1] @l + [1 1] @m' + [0] [1 0] [1 1] [1] >= [1 1] @l + [1 1] @m' + [0] [0 0] [1 1] [1] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [1 1] @l + [1 1] @y + [1 1] @ys + [1] [0 0] [1 1] [1 1] [2] >= [1 1] @l + [1 1] @y + [1 1] @ys + [1] [0 0] [1 1] [1 0] [2] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [1 1] @l + [0] [0 0] [1] >= [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [0 1] @m2 + [0] [1 1] [1] >= [0 1] @m2 + [0] [0 0] [1] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0 0] @x + [0 1] @xs + [1] [1 1] [1 0] [1] > [0 1] @xs + [0] [0 0] [0] = [c_2(lineMult^#(@l, @xs))] [matrixMult^#(@m1, @m2)] = [1 1] @m2 + [1] [0 0] [0] > [1 1] @m2 + [0] [0 0] [0] = [c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult'^#(@m1, @m2)] = [0 1] @m2 + [0] [0 0] [0] >= [0 1] @m2 + [0] [0 0] [0] = [c_4(matrixMult'#1^#(@m1, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 0] @l + [0 0] @ls + [0 1] @m2 + [0] [1 1] [1 0] [1 1] [0] >= [0 1] @m2 + [0] [0 0] [0] = [c_5(lineMult^#(@l, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 0] @l + [0 0] @ls + [0 1] @m2 + [0] [1 1] [1 0] [1 1] [0] >= [0 1] @m2 + [0] [0 0] [0] = [c_6(matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1] [1 1] [1 1] [1 1] [1] >= [1 1] @m3 + [1] [0 0] [1] = [c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1 1] @mm + [1] [0 0] [0] >= [1 1] @mm + [1] [0 0] [0] = [c_8(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 1] @ms + [2] [0 0] [0 1] [2] > [1 1] @m + [1] [0 0] [0] = [c_9(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 1] @ms + [2] [0 0] [0 1] [2] > [1 1] @ms + [1] [0 0] [0] = [c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 0] @m2 + [1] [1 1] [1 1] [1] >= [1 0] @m2 + [1] [0 0] [0] = [c_11(matrixMult'^#(@m1, transpose(@m2)))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , 3: matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 4: matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2)) , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , 6: matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2)) , 7: matrixMult3^#(@m1, @m2, @m3) -> c_7(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 8: matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc)) , 9: matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , 10: matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 11: matrixMultOld^#(@m1, @m2) -> c_11(matrixMult'^#(@m1, transpose(@m2))) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,3,9,10}. These cover all (indirect) predecessors of dependency pairs {2,3,7,8,9,10,11}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) } Weak DPs: { lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_7(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_11(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , 9: matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) } Trs: { attach#2(nil(), @x, @xs) -> nil() , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , makeBase(@m) -> makeBase#1(@m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transpose#1(nil(), @m) -> nil() , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0 0] x1 + [0] [0 1] [0] [#neg](x1) = [0 0] x1 + [0] [1 1] [0] [#pos](x1) = [1 0] x1 + [0] [0 1] [0] [#s](x1) = [0 0] x1 + [0] [1 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [1 0] x2 + [0] [0 0] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [0] [nil] = [0] [0] [lineMult](x1, x2) = [0 0] x1 + [0 0] x2 + [0] [1 0] [1 0] [0] [lineMult#1](x1, x2) = [0 1] x1 + [1 0] x2 + [0] [1 0] [1 0] [1] [mult](x1, x2) = [0] [0] [makeBase](x1) = [1 0] x1 + [1] [1 0] [0] [makeBase#1](x1) = [1 0] x1 + [0] [1 0] [0] [mkBase](x1) = [0 1] x1 + [0] [1 1] [0] [matrixMult](x1, x2) = [0 0] x1 + [0] [1 1] [0] [transAcc](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [matrixMult'](x1, x2) = [0 0] x1 + [0] [1 1] [0] [matrixMult'#1](x1, x2) = [0 0] x1 + [1 0] x2 + [0] [1 1] [0 1] [0] [transpose](x1) = [1 1] x1 + [1] [1 1] [0] [mkBase#1](x1) = [0 1] x1 + [0] [1 1] [0] [mult#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [1 0] [0] [mult#2](x1, x2, x3) = [0 0] x2 + [0 0] x3 + [0] [1 1] [1 1] [0] [split](x1) = [0 1] x1 + [0] [1 0] [1] [split#1](x1) = [0 1] x1 + [0] [1 0] [1] [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [1] [1 1] [1 0] [1] [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0] [1 0] [1 1] [1] [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [1] [0 1] [1 1] [1 1] [1] [transAcc#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [transpose#1](x1, x2) = [0 0] x1 + [1 1] x2 + [1] [0 1] [1 0] [0] [transpose#2](x1) = [1 1] x1 + [0] [0 1] [0] [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [1] [1 1] [0 0] [1] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [lineMult#1^#](x1, x2) = [0 1] x1 + [0] [0 0] [0] [mult^#](x1, x2) = [0] [0] [mult#1^#](x1, x2) = [0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [1 1] x2 + [1] [0 0] [0] [matrixMult'^#](x1, x2) = [0 0] x1 + [0 1] x2 + [1] [1 1] [0 0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0 1] x2 + [1] [0 0] [0] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [1 1] x2 + [1] [0 0] [0] [matrixMultList#1^#](x1, x2) = [1 1] x1 + [0 0] x2 + [1] [0 0] [1 1] [0] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_7](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 1] x1 + [0] [0 0] [0] [c_2](x1) = [1 1] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 1] x1 + [0] [0 0] [0] [c_5](x1) = [1 1] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] [c_9](x1) = [1 1] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [1] [0 0] [0] [c_11](x1) = [1 0] x1 + [0] [0 0] [1] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] >= [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] >= [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [0] [0 1] [0] >= [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [1] [0 0] [0 0] [0] > [0] [0] = [nil()] [makeBase(@m)] = [1 0] @m + [1] [1 0] [0] > [1 0] @m + [0] [1 0] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [1 1] @l + [1 0] @m' + [0] [1 1] [1 0] [0] >= [0 1] @l + [0] [1 1] [0] = [mkBase(@l)] [makeBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [mkBase(@m)] = [0 1] @m + [0] [1 1] [0] >= [0 1] @m + [0] [1 1] [0] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 1] @m + [0] [0 1] [0 1] [0] >= [1 0] @base + [1 1] @m + [0] [0 1] [0 1] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [1] [1 1] [0] >= [1 1] @m + [1] [1 1] [0] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [0 0] @l + [0 1] @m' + [1] [1 1] [1 1] [1] > [0 1] @m' + [0] [1 1] [1] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [split(@m)] = [0 1] @m + [0] [1 0] [1] >= [0 1] @m + [0] [1 0] [1] = [split#1(@m)] [split#1(::(@l, @ls))] = [0 0] @l + [0 1] @ls + [1] [1 1] [1 0] [1] >= [0 0] @l + [0 1] @ls + [1] [1 1] [1 0] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [1] >= [0] [1] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [0 1] @ls + [0 0] @x + [0 0] @xs + [1] [1 0] [1 1] [1 1] [2] >= [0 1] @ls + [0 0] @x + [0 0] @xs + [1] [1 0] [1 1] [1 1] [2] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [0 1] @ls + [1] [1 0] [1] > [0] [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1] [1 1] [1 1] [1 1] [1 0] [2] >= [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1] [1 1] [1 1] [1 1] [1 0] [2] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 1] @m' + [1] [0 1] [0 0] [0 1] [1] > [1 0] @base + [1 1] @l + [1 1] @m' + [0] [0 1] [0 0] [0 1] [0] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [0 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [1 1] @m + [0 0] @xss + [1] [1 0] [0 1] [1] >= [1 1] @m + [1] [1 0] [1] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [1 1] @m + [1] [1 0] [0] > [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [1 1] @l + [1 1] @m' + [1] [1 0] [1 1] [1] >= [1 1] @l + [1 1] @m' + [1] [0 0] [1 1] [1] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 1] [2] >= [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 1] [2] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [1 1] @l + [1] [0 0] [1] > [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [0 1] @m2 + [0] [0 0] [0] >= [0 1] @m2 + [0] [0 0] [0] = [c_1(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0 1] @xs + [1] [0 0] [0] > [0 1] @xs + [0] [0 0] [0] = [c_2(lineMult^#(@l, @xs))] [matrixMult^#(@m1, @m2)] = [1 1] @m2 + [1] [0 0] [0] >= [1 1] @m2 + [1] [0 0] [0] = [c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult'^#(@m1, @m2)] = [0 0] @m1 + [0 1] @m2 + [1] [1 1] [0 0] [0] >= [0 1] @m2 + [1] [0 0] [0] = [c_4(matrixMult'#1^#(@m1, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 1] @m2 + [1] [0 0] [0] > [0 1] @m2 + [0] [0 0] [0] = [c_5(lineMult^#(@l, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 1] @m2 + [1] [0 0] [0] >= [0 1] @m2 + [1] [0 0] [0] = [c_6(matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1] [1 1] [1 1] [1 1] [1] >= [1 1] @m3 + [1] [0 0] [0] = [c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1 1] @mm + [1] [0 0] [0] >= [1 1] @mm + [1] [0 0] [0] = [c_8(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [0 0] @acc + [1 1] @m + [1 1] @ms + [2] [1 1] [0 0] [0 0] [0] > [1 1] @m + [1] [0 0] [0] = [c_9(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [0 0] @acc + [1 1] @m + [1 1] @ms + [2] [1 1] [0 0] [0 0] [0] >= [1 1] @ms + [2] [0 0] [0] = [c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 1] @m2 + [1] [1 1] [1 1] [1] >= [1 1] @m2 + [1] [0 0] [1] = [c_11(matrixMult'^#(@m1, transpose(@m2)))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , 3: matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 4: matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2)) , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , 6: matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2)) , 7: matrixMult3^#(@m1, @m2, @m3) -> c_7(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 8: matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc)) , 9: matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , 10: matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 11: matrixMultOld^#(@m1, @m2) -> c_11(matrixMult'^#(@m1, transpose(@m2))) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,5,9}. These cover all (indirect) predecessors of dependency pairs {1,2,3,5,7,9,11}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_7(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_11(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) , matrixMult^#(@m1, @m2) -> c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_7(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_11(matrixMult'^#(@m1, transpose(@m2))) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 2.637302s CPU-time: 18.238s Wall-time: 1.316066s CPU-time: 8.383s Wall-time: 72.211023s CPU-time: 605.189s Hurray, we answered YES(O(1),O(n^3))